Obeleži sve kategorije koje odgovaraju problemu

Petlje su nam omogućile da na kratak način opišemo repetitivne postupke koji mogu biti veoma dugački. Još jedan element nam nedostaje da bismo mogli da jednostavno opišemo većinu takvih postupaka.

Recimo da imamo problem gde nam je potrebno da unesemo 100 brojeva u program. Da ne bismo imali komandu za unos podatka 100 puta u programu, za ovako nešto želimo da upotrebimo petlju. Ipak kada pokušamo da je upotrebimo javlja se nekoliko problema.

Prvo moramo da definišemo 100 promenljivih u koje ćemo smestiti te brojeve. Za ovo ne možemo da upotrebimo petlju kako je prikazano u sledećem programu.

static void Main(string[] args)
{
    for (int i = 0; i < 100; i++)
    {
        int broj;
    }
}

Kreirana na ovaj način, promenljiva broj ne bi bila definisana van petlje. Međutim, čak i kada bi bila, u svakom prolazu kroz petlju ponovo bismo definisali istu promenljivu i nemamo način da kažemo u petlji da hoćemo novu promenljivu u svakom prolazu.

Postoji način da jednom komandom definišemo koliko god želimo promenljivih. Ovakvu grupu promenljivih nazivamo niz. Niz se definiše slično običnoj promenljivoj. Tako, ako recimo hoćemo da definišemo niz od 100 celobrojnih promenljivih, kao što nam treba u našem primeru, to možemo uraditi sledećom komandom:

int[] brojevi = new int[100];

Ova komanda definiše u memoriji niz od 100 promenljivih pod nazivom brojevi. Promenljive koje čine ovaj niz su numerisane od 0 do 99. Obratite pažnju, numerisanje uvek počinje od 0 i ide do broja elemenata u nizu umanjenog za 1. Evo kako to izgleda u memoriji:

Svakoj promenljivoj pojedinačno pristupimo tako što posle imena niza u uglastim zagradama prosledimo indeks tog elementa. Tako na primer, ako želimo da pristupimo prvom elementu u nizu koji ima indeks 0, to radimo tako što napišemo brojevi[0].

Kada pristupimo elementu niza, možemo sa njim raditi sve što možemo i sa običnom promenljivom: koristiti ga u računici, dodeliti mu vrednost, itd.

Pogledajmo jedan primer, gde ćemo u komentarima naznačiti koje je stanje u memoriji nakon svake komande.

static void Main(string[] args)
{
    int[] brojevi = new int[3];
    // brojevi[0]: podrazumevana vrednost 0
    // brojevi[1]: podrazumevana vrednost 0
    // brojevi[2]: podrazumevana vrednost 0

    brojevi[0] = 2;
    // brojevi[0]: 2
    // brojevi[1]: podrazumevana vrednost 0
    // brojevi[2]: podrazumevana vrednost 0

    brojevi[2] = 4;
    // brojevi[0]: 2
    // brojevi[1]: podrazumevana vrednost 0
    // brojevi[2]: 4

    brojevi[1] = brojevi[0] + brojevi[2];
    // brojevi[0]: 2
    // brojevi[1]: 6
    // brojevi[2]: 4
}

Kada hoćemo da pristupimo elementu niza ne moramo obavezno napisati samo broj u uglastim zagradama. Možemo u njih staviti bilo koji izraz koji, kada se izračuna, ima celobrojnu vrednost. Pogledajmo sledeći primer.

static void Main(string[] args)
{
    int indeks = 0;

    int[] brojevi = new int[3];
    // brojevi[0]: podrazumevana vrednost 0
    // brojevi[1]: podrazumevana vrednost 0
    // brojevi[2]: podrazumevana vrednost 0

    brojevi[indeks] = 1;
    // brojevi[0]: 1
    // brojevi[1]: podrazumevana vrednost 0
    // brojevi[2]: podrazumevana vrednost 0

    brojevi[indeks + 1] = 2;
    // brojevi[0]: 1
    // brojevi[1]: 2
    // brojevi[2]: podrazumevana vrednost 0

    brojevi[indeks + 2] = 5;
    // brojevi[0]: 1
    // brojevi[1]: 2
    // brojevi[2]: 5
}

Niz se ne mora sastojati od celobrojnih promenljivih, već promenljive mogu biti kog tipa koji smo do sada videli.

Tako na primer možemo imati niz stringova.

static void Main(string[] args)
{
    string[] reci = new string[3];
    // reci[0]: podrazumevana vrednost-prazan tekst
    // reci[1]: podrazumevana vrednost-prazan tekst
    // reci[2]: podrazumevana vrednost-prazan tekst

    reci[2] = "zoves?";
    // reci[0]: podrazumevana vrednost-prazan tekst
    // reci[1]: podrazumevana vrednost-prazan tekst
    // reci[2]: "zoves?"

    reci[0] = "Kako";
    // reci[0]: "Kako"
    // reci[1]: podrazumevana vrednost-prazan tekst
    // reci[2]: "zoves?"

    reci[1] = "se";
    // reci[0]: "Kako"
    // reci[1]: "se"
    // reci[2]: "zoves?"

    Console.WriteLine(reci[0] + " " + reci[1] + " " + reci[2]);
    // Ispisuje se: "Kako se zoves?"
}

Uradimo još jedan primer da bismo se uhodali u radu sa nizovima. Recimo da se unosi broj n, a zatim n brojeva između 1 i 10. Ono što hoćemo da uradimo je da ispišemo koliko puta se svaki od brojeva pojavio.

static void Main(string[] args)
{
    int n;
    n = int.Parse(Console.ReadLine());

    /*
    Definisemo niz u kome cemo za svaki broj
    od 1 do 10 pamtiti koliko puta se pojavio.
    Definisemo ovaj niz duzine 11, jer zelimo da
    koristimo elemente od 1 do 10 ukljucujuci i
    10. Da smo definisali niz duzine 10 imali bi
    samo elemente od 0 do 9.
    */

    int[] koliko_puta = new int[11];
    // Vrednosti promenljivih u nizu su sve na pocetku 0.

    for (int i = 0; i < n; i++)
    {
        /*
        Unutar petlje definisemo promenljivu u kojoj 
        cemo ucitati sledeci broj. Uoci da nemamo niz u
        kome pamtimo sve ove brojeve, to nam nije potrebno,
        samo pamtimo koliko puta se svaki pojavio.
        */

        int novi_broj;
        novi_broj = int.Parse(Console.ReadLine());

        // Uvecamo broj pojavljivanja broja koji smo ucitali za 1.
        koliko_puta[novi_broj]++;
    }

    // Na kraju za svaki broj ispisemo koliko puta se pojavio.
    for (int broj = 1; broj <= 10; broj++)
    {
        Console.WriteLine("Broj " + broj + " se pojavljuje " + koliko_puta[broj]);
    }
}